home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 June / PersonalComputerWorld-June2009-CoverdiscCD.iso / Software / Freeware / Adobe AIR 1.5.1 / AdobeAIRInstaller.exe / setup.swf / scripts / mx / managers / ToolTipManagerImpl.as < prev   
Encoding:
Text File  |  2009-02-12  |  21.9 KB  |  692 lines
  1. package mx.managers
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.events.Event;
  5.    import flash.events.EventDispatcher;
  6.    import flash.events.MouseEvent;
  7.    import flash.events.TimerEvent;
  8.    import flash.geom.Point;
  9.    import flash.geom.Rectangle;
  10.    import flash.utils.Timer;
  11.    import mx.controls.ToolTip;
  12.    import mx.core.ApplicationGlobals;
  13.    import mx.core.IInvalidating;
  14.    import mx.core.IToolTip;
  15.    import mx.core.IUIComponent;
  16.    import mx.core.mx_internal;
  17.    import mx.effects.EffectManager;
  18.    import mx.effects.IAbstractEffect;
  19.    import mx.events.EffectEvent;
  20.    import mx.events.ToolTipEvent;
  21.    import mx.styles.IStyleClient;
  22.    import mx.validators.IValidatorListener;
  23.    
  24.    use namespace mx_internal;
  25.    
  26.    public class ToolTipManagerImpl extends EventDispatcher implements IToolTipManager2
  27.    {
  28.       private static var instance:IToolTipManager2;
  29.       
  30.       mx_internal static const VERSION:String = "3.0.0.0";
  31.       
  32.       private var _enabled:Boolean = true;
  33.       
  34.       mx_internal var isError:Boolean;
  35.       
  36.       private var _showDelay:Number = 500;
  37.       
  38.       private var _hideEffect:IAbstractEffect;
  39.       
  40.       mx_internal var hideTimer:Timer;
  41.       
  42.       private var _scrubDelay:Number = 100;
  43.       
  44.       private var _toolTipClass:Class;
  45.       
  46.       mx_internal var currentText:String;
  47.       
  48.       mx_internal var showTimer:Timer;
  49.       
  50.       private var _currentToolTip:IToolTip;
  51.       
  52.       mx_internal var scrubTimer:Timer;
  53.       
  54.       mx_internal var previousTarget:DisplayObject;
  55.       
  56.       private var _currentTarget:DisplayObject;
  57.       
  58.       private var _showEffect:IAbstractEffect;
  59.       
  60.       mx_internal var initialized:Boolean = false;
  61.       
  62.       private var _hideDelay:Number = 10000;
  63.       
  64.       public function ToolTipManagerImpl()
  65.       {
  66.          _toolTipClass = ToolTip;
  67.          super();
  68.          if(instance)
  69.          {
  70.             throw new Error("Instance already exists.");
  71.          }
  72.       }
  73.       
  74.       public static function getInstance() : IToolTipManager2
  75.       {
  76.          if(!instance)
  77.          {
  78.             instance = new ToolTipManagerImpl();
  79.          }
  80.          return instance;
  81.       }
  82.       
  83.       mx_internal function systemManager_mouseDownHandler(param1:MouseEvent) : void
  84.       {
  85.          mx_internal::reset();
  86.       }
  87.       
  88.       public function set showDelay(param1:Number) : void
  89.       {
  90.          _showDelay = param1;
  91.       }
  92.       
  93.       mx_internal function hideEffectEnded() : void
  94.       {
  95.          var _loc1_:ToolTipEvent = null;
  96.          mx_internal::reset();
  97.          if(mx_internal::previousTarget)
  98.          {
  99.             _loc1_ = new ToolTipEvent(ToolTipEvent.TOOL_TIP_END);
  100.             _loc1_.toolTip = currentToolTip;
  101.             mx_internal::previousTarget.dispatchEvent(_loc1_);
  102.          }
  103.       }
  104.       
  105.       public function set scrubDelay(param1:Number) : void
  106.       {
  107.          _scrubDelay = param1;
  108.       }
  109.       
  110.       public function get currentToolTip() : IToolTip
  111.       {
  112.          return _currentToolTip;
  113.       }
  114.       
  115.       private function mouseIsOver(param1:DisplayObject) : Boolean
  116.       {
  117.          if(!param1 || !param1.stage)
  118.          {
  119.             return false;
  120.          }
  121.          if(param1.stage.mouseX == 0 && param1.stage.mouseY == 0)
  122.          {
  123.             return false;
  124.          }
  125.          return param1.hitTestPoint(param1.stage.mouseX,param1.stage.mouseY,true);
  126.       }
  127.       
  128.       mx_internal function toolTipMouseOutHandler(param1:MouseEvent) : void
  129.       {
  130.          mx_internal::checkIfTargetChanged(param1.relatedObject);
  131.       }
  132.       
  133.       public function get enabled() : Boolean
  134.       {
  135.          return _enabled;
  136.       }
  137.       
  138.       public function createToolTip(param1:String, param2:Number, param3:Number, param4:String = null, param5:IUIComponent = null) : IToolTip
  139.       {
  140.          var _loc6_:ToolTip = new ToolTip();
  141.          var _loc7_:ISystemManager = !!param5 ? param5.systemManager : ApplicationGlobals.application.systemManager;
  142.          _loc7_.toolTipChildren.addChild(_loc6_);
  143.          if(param4)
  144.          {
  145.             _loc6_.setStyle("styleName","errorTip");
  146.             _loc6_.setStyle("borderStyle",param4);
  147.          }
  148.          _loc6_.text = param1;
  149.          sizeTip(_loc6_);
  150.          _loc6_.move(param2,param3);
  151.          return _loc6_ as IToolTip;
  152.       }
  153.       
  154.       mx_internal function reset() : void
  155.       {
  156.          var _loc1_:ISystemManager = null;
  157.          mx_internal::showTimer.reset();
  158.          mx_internal::hideTimer.reset();
  159.          if(currentToolTip)
  160.          {
  161.             if(Boolean(showEffect) || Boolean(hideEffect))
  162.             {
  163.                currentToolTip.removeEventListener(EffectEvent.EFFECT_END,mx_internal::effectEndHandler);
  164.             }
  165.             EffectManager.endEffectsForTarget(currentToolTip);
  166.             _loc1_ = currentToolTip.systemManager;
  167.             _loc1_.toolTipChildren.removeChild(DisplayObject(currentToolTip));
  168.             currentToolTip = null;
  169.             mx_internal::scrubTimer.delay = scrubDelay;
  170.             mx_internal::scrubTimer.reset();
  171.             if(scrubDelay > 0)
  172.             {
  173.                mx_internal::scrubTimer.delay = scrubDelay;
  174.                mx_internal::scrubTimer.start();
  175.             }
  176.          }
  177.       }
  178.       
  179.       public function get toolTipClass() : Class
  180.       {
  181.          return _toolTipClass;
  182.       }
  183.       
  184.       public function set currentToolTip(param1:IToolTip) : void
  185.       {
  186.          _currentToolTip = param1;
  187.       }
  188.       
  189.       private function hideImmediately(param1:DisplayObject) : void
  190.       {
  191.          mx_internal::checkIfTargetChanged(null);
  192.       }
  193.       
  194.       mx_internal function showTip() : void
  195.       {
  196.          var _loc2_:ISystemManager = null;
  197.          var _loc1_:ToolTipEvent = new ToolTipEvent(ToolTipEvent.TOOL_TIP_SHOW);
  198.          _loc1_.toolTip = currentToolTip;
  199.          currentTarget.dispatchEvent(_loc1_);
  200.          if(mx_internal::isError)
  201.          {
  202.             currentTarget.addEventListener("change",mx_internal::changeHandler);
  203.          }
  204.          else
  205.          {
  206.             _loc2_ = getSystemManager(currentTarget);
  207.             _loc2_.addEventListener(MouseEvent.MOUSE_DOWN,mx_internal::systemManager_mouseDownHandler);
  208.          }
  209.          currentToolTip.visible = true;
  210.          if(!showEffect)
  211.          {
  212.             mx_internal::showEffectEnded();
  213.          }
  214.       }
  215.       
  216.       mx_internal function effectEndHandler(param1:EffectEvent) : void
  217.       {
  218.          if(param1.effectInstance.effect == showEffect)
  219.          {
  220.             mx_internal::showEffectEnded();
  221.          }
  222.          else if(param1.effectInstance.effect == hideEffect)
  223.          {
  224.             mx_internal::hideEffectEnded();
  225.          }
  226.       }
  227.       
  228.       public function get hideDelay() : Number
  229.       {
  230.          return _hideDelay;
  231.       }
  232.       
  233.       public function get currentTarget() : DisplayObject
  234.       {
  235.          return _currentTarget;
  236.       }
  237.       
  238.       mx_internal function showEffectEnded() : void
  239.       {
  240.          var _loc1_:ToolTipEvent = null;
  241.          if(hideDelay == 0)
  242.          {
  243.             mx_internal::hideTip();
  244.          }
  245.          else if(hideDelay < Infinity)
  246.          {
  247.             mx_internal::hideTimer.delay = hideDelay;
  248.             mx_internal::hideTimer.start();
  249.          }
  250.          if(currentTarget)
  251.          {
  252.             _loc1_ = new ToolTipEvent(ToolTipEvent.TOOL_TIP_SHOWN);
  253.             _loc1_.toolTip = currentToolTip;
  254.             currentTarget.dispatchEvent(_loc1_);
  255.          }
  256.       }
  257.       
  258.       public function get hideEffect() : IAbstractEffect
  259.       {
  260.          return _hideEffect;
  261.       }
  262.       
  263.       mx_internal function changeHandler(param1:Event) : void
  264.       {
  265.          mx_internal::reset();
  266.       }
  267.       
  268.       public function set enabled(param1:Boolean) : void
  269.       {
  270.          _enabled = param1;
  271.       }
  272.       
  273.       mx_internal function errorTipMouseOverHandler(param1:MouseEvent) : void
  274.       {
  275.          mx_internal::checkIfTargetChanged(DisplayObject(param1.target));
  276.       }
  277.       
  278.       public function get showDelay() : Number
  279.       {
  280.          return _showDelay;
  281.       }
  282.       
  283.       public function registerErrorString(param1:DisplayObject, param2:String, param3:String) : void
  284.       {
  285.          if(!param2 && Boolean(param3))
  286.          {
  287.             param1.addEventListener(MouseEvent.MOUSE_OVER,mx_internal::errorTipMouseOverHandler);
  288.             param1.addEventListener(MouseEvent.MOUSE_OUT,mx_internal::errorTipMouseOutHandler);
  289.             if(mouseIsOver(param1))
  290.             {
  291.                showImmediately(param1);
  292.             }
  293.          }
  294.          else if(Boolean(param2) && !param3)
  295.          {
  296.             param1.removeEventListener(MouseEvent.MOUSE_OVER,mx_internal::errorTipMouseOverHandler);
  297.             param1.removeEventListener(MouseEvent.MOUSE_OUT,mx_internal::errorTipMouseOutHandler);
  298.             if(mouseIsOver(param1))
  299.             {
  300.                hideImmediately(param1);
  301.             }
  302.          }
  303.       }
  304.       
  305.       mx_internal function initialize() : void
  306.       {
  307.          if(!mx_internal::showTimer)
  308.          {
  309.             mx_internal::showTimer = new Timer(0,1);
  310.             mx_internal::showTimer.addEventListener(TimerEvent.TIMER,mx_internal::showTimer_timerHandler);
  311.          }
  312.          if(!mx_internal::hideTimer)
  313.          {
  314.             mx_internal::hideTimer = new Timer(0,1);
  315.             mx_internal::hideTimer.addEventListener(TimerEvent.TIMER,mx_internal::hideTimer_timerHandler);
  316.          }
  317.          if(!mx_internal::scrubTimer)
  318.          {
  319.             mx_internal::scrubTimer = new Timer(0,1);
  320.          }
  321.          mx_internal::initialized = true;
  322.       }
  323.       
  324.       public function destroyToolTip(param1:IToolTip) : void
  325.       {
  326.          var _loc2_:ISystemManager = param1.systemManager;
  327.          _loc2_.toolTipChildren.removeChild(DisplayObject(param1));
  328.       }
  329.       
  330.       public function get scrubDelay() : Number
  331.       {
  332.          return _scrubDelay;
  333.       }
  334.       
  335.       mx_internal function checkIfTargetChanged(param1:DisplayObject) : void
  336.       {
  337.          if(!enabled)
  338.          {
  339.             return;
  340.          }
  341.          mx_internal::findTarget(param1);
  342.          if(currentTarget != mx_internal::previousTarget)
  343.          {
  344.             mx_internal::targetChanged();
  345.             mx_internal::previousTarget = currentTarget;
  346.          }
  347.       }
  348.       
  349.       public function set toolTipClass(param1:Class) : void
  350.       {
  351.          _toolTipClass = param1;
  352.       }
  353.       
  354.       private function getGlobalBounds(param1:DisplayObject) : Rectangle
  355.       {
  356.          var _loc2_:Point = new Point(0,0);
  357.          _loc2_ = param1.localToGlobal(_loc2_);
  358.          return new Rectangle(_loc2_.x,_loc2_.y,param1.width,param1.height);
  359.       }
  360.       
  361.       mx_internal function positionTip() : void
  362.       {
  363.          var _loc1_:Number = NaN;
  364.          var _loc2_:Number = NaN;
  365.          var _loc5_:Rectangle = null;
  366.          var _loc6_:Point = null;
  367.          var _loc7_:IToolTip = null;
  368.          var _loc8_:Number = NaN;
  369.          var _loc9_:Number = NaN;
  370.          var _loc10_:Number = NaN;
  371.          var _loc11_:Number = NaN;
  372.          var _loc3_:Number = currentToolTip.screen.width;
  373.          var _loc4_:Number = currentToolTip.screen.height;
  374.          if(mx_internal::isError)
  375.          {
  376.             _loc5_ = getGlobalBounds(currentTarget);
  377.             _loc1_ = _loc5_.right + 4;
  378.             _loc2_ = _loc5_.top - 1;
  379.             if(_loc1_ + currentToolTip.width > _loc3_)
  380.             {
  381.                _loc8_ = NaN;
  382.                _loc9_ = NaN;
  383.                _loc1_ = _loc5_.left - 2;
  384.                if(_loc1_ + currentToolTip.width + 4 > _loc3_)
  385.                {
  386.                   _loc8_ = _loc3_ - _loc1_ - 4;
  387.                   _loc9_ = Number(Object(toolTipClass).maxWidth);
  388.                   Object(toolTipClass).maxWidth = _loc8_;
  389.                   if(currentToolTip is IStyleClient)
  390.                   {
  391.                      IStyleClient(currentToolTip).setStyle("borderStyle","errorTipAbove");
  392.                   }
  393.                   currentToolTip["text"] = currentToolTip["text"];
  394.                   Object(toolTipClass).maxWidth = _loc9_;
  395.                }
  396.                else
  397.                {
  398.                   if(currentToolTip is IStyleClient)
  399.                   {
  400.                      IStyleClient(currentToolTip).setStyle("borderStyle","errorTipAbove");
  401.                   }
  402.                   currentToolTip["text"] = currentToolTip["text"];
  403.                }
  404.                if(currentToolTip.height + 2 < _loc5_.top)
  405.                {
  406.                   _loc2_ = _loc5_.top - (currentToolTip.height + 2);
  407.                }
  408.                else
  409.                {
  410.                   _loc2_ = _loc5_.bottom + 2;
  411.                   if(!isNaN(_loc8_))
  412.                   {
  413.                      Object(toolTipClass).maxWidth = _loc8_;
  414.                   }
  415.                   if(currentToolTip is IStyleClient)
  416.                   {
  417.                      IStyleClient(currentToolTip).setStyle("borderStyle","errorTipBelow");
  418.                   }
  419.                   currentToolTip["text"] = currentToolTip["text"];
  420.                   if(!isNaN(_loc9_))
  421.                   {
  422.                      Object(toolTipClass).maxWidth = _loc9_;
  423.                   }
  424.                }
  425.             }
  426.             sizeTip(currentToolTip);
  427.             _loc6_ = new Point(_loc1_,_loc2_);
  428.             _loc7_ = currentToolTip;
  429.             _loc6_ = DisplayObject(_loc7_).root.globalToLocal(_loc6_);
  430.             _loc1_ = _loc6_.x;
  431.             _loc2_ = _loc6_.y;
  432.          }
  433.          else
  434.          {
  435.             _loc1_ = ApplicationGlobals.application.mouseX + 11;
  436.             _loc2_ = ApplicationGlobals.application.mouseY + 22;
  437.             _loc10_ = Number(currentToolTip.width);
  438.             if(_loc1_ + _loc10_ > _loc3_)
  439.             {
  440.                _loc1_ = _loc3_ - _loc10_;
  441.             }
  442.             _loc11_ = Number(currentToolTip.height);
  443.             if(_loc2_ + _loc11_ > _loc4_)
  444.             {
  445.                _loc2_ = _loc4_ - _loc11_;
  446.             }
  447.          }
  448.          currentToolTip.move(_loc1_,_loc2_);
  449.       }
  450.       
  451.       mx_internal function errorTipMouseOutHandler(param1:MouseEvent) : void
  452.       {
  453.          mx_internal::checkIfTargetChanged(param1.relatedObject);
  454.       }
  455.       
  456.       mx_internal function findTarget(param1:DisplayObject) : void
  457.       {
  458.          while(param1)
  459.          {
  460.             if(param1 is IValidatorListener)
  461.             {
  462.                mx_internal::currentText = IValidatorListener(param1).errorString;
  463.                if(mx_internal::currentText != null && mx_internal::currentText != "")
  464.                {
  465.                   currentTarget = param1;
  466.                   mx_internal::isError = true;
  467.                   return;
  468.                }
  469.             }
  470.             if(param1 is IToolTipManagerClient)
  471.             {
  472.                mx_internal::currentText = IToolTipManagerClient(param1).toolTip;
  473.                if(mx_internal::currentText != null)
  474.                {
  475.                   currentTarget = param1;
  476.                   mx_internal::isError = false;
  477.                   return;
  478.                }
  479.             }
  480.             param1 = param1.parent;
  481.          }
  482.          mx_internal::currentText = null;
  483.          currentTarget = null;
  484.       }
  485.       
  486.       public function registerToolTip(param1:DisplayObject, param2:String, param3:String) : void
  487.       {
  488.          if(!param2 && Boolean(param3))
  489.          {
  490.             param1.addEventListener(MouseEvent.MOUSE_OVER,mx_internal::toolTipMouseOverHandler);
  491.             param1.addEventListener(MouseEvent.MOUSE_OUT,mx_internal::toolTipMouseOutHandler);
  492.             if(mouseIsOver(param1))
  493.             {
  494.                showImmediately(param1);
  495.             }
  496.          }
  497.          else if(Boolean(param2) && !param3)
  498.          {
  499.             param1.removeEventListener(MouseEvent.MOUSE_OVER,mx_internal::toolTipMouseOverHandler);
  500.             param1.removeEventListener(MouseEvent.MOUSE_OUT,mx_internal::toolTipMouseOutHandler);
  501.             if(mouseIsOver(param1))
  502.             {
  503.                hideImmediately(param1);
  504.             }
  505.          }
  506.       }
  507.       
  508.       private function showImmediately(param1:DisplayObject) : void
  509.       {
  510.          var _loc2_:Number = ToolTipManager.showDelay;
  511.          ToolTipManager.showDelay = 0;
  512.          mx_internal::checkIfTargetChanged(param1);
  513.          ToolTipManager.showDelay = _loc2_;
  514.       }
  515.       
  516.       public function set hideDelay(param1:Number) : void
  517.       {
  518.          _hideDelay = param1;
  519.       }
  520.       
  521.       private function getSystemManager(param1:DisplayObject) : ISystemManager
  522.       {
  523.          return param1 is IUIComponent ? IUIComponent(param1).systemManager : null;
  524.       }
  525.       
  526.       public function set currentTarget(param1:DisplayObject) : void
  527.       {
  528.          _currentTarget = param1;
  529.       }
  530.       
  531.       public function sizeTip(param1:IToolTip) : void
  532.       {
  533.          if(param1 is IInvalidating)
  534.          {
  535.             IInvalidating(param1).validateNow();
  536.          }
  537.          param1.setActualSize(param1.getExplicitOrMeasuredWidth(),param1.getExplicitOrMeasuredHeight());
  538.       }
  539.       
  540.       mx_internal function showTimer_timerHandler(param1:TimerEvent) : void
  541.       {
  542.          if(currentTarget)
  543.          {
  544.             mx_internal::createTip();
  545.             mx_internal::initializeTip();
  546.             mx_internal::positionTip();
  547.             mx_internal::showTip();
  548.          }
  549.       }
  550.       
  551.       mx_internal function hideTimer_timerHandler(param1:TimerEvent) : void
  552.       {
  553.          mx_internal::hideTip();
  554.       }
  555.       
  556.       public function set showEffect(param1:IAbstractEffect) : void
  557.       {
  558.          _showEffect = param1 as IAbstractEffect;
  559.       }
  560.       
  561.       public function set hideEffect(param1:IAbstractEffect) : void
  562.       {
  563.          _hideEffect = param1 as IAbstractEffect;
  564.       }
  565.       
  566.       mx_internal function targetChanged() : void
  567.       {
  568.          var _loc1_:ToolTipEvent = null;
  569.          if(!mx_internal::initialized)
  570.          {
  571.             mx_internal::initialize();
  572.          }
  573.          if(Boolean(mx_internal::previousTarget) && Boolean(currentToolTip))
  574.          {
  575.             _loc1_ = new ToolTipEvent(ToolTipEvent.TOOL_TIP_HIDE);
  576.             _loc1_.toolTip = currentToolTip;
  577.             mx_internal::previousTarget.dispatchEvent(_loc1_);
  578.          }
  579.          mx_internal::reset();
  580.          if(currentTarget)
  581.          {
  582.             if(mx_internal::currentText == "")
  583.             {
  584.                return;
  585.             }
  586.             _loc1_ = new ToolTipEvent(ToolTipEvent.TOOL_TIP_START);
  587.             currentTarget.dispatchEvent(_loc1_);
  588.             if(showDelay == 0 || mx_internal::scrubTimer.running)
  589.             {
  590.                mx_internal::createTip();
  591.                mx_internal::initializeTip();
  592.                mx_internal::positionTip();
  593.                mx_internal::showTip();
  594.             }
  595.             else
  596.             {
  597.                mx_internal::showTimer.delay = showDelay;
  598.                mx_internal::showTimer.start();
  599.             }
  600.          }
  601.       }
  602.       
  603.       mx_internal function initializeTip() : void
  604.       {
  605.          if(currentToolTip is ToolTip)
  606.          {
  607.             ToolTip(currentToolTip).text = mx_internal::currentText;
  608.          }
  609.          if(mx_internal::isError && currentToolTip is IStyleClient)
  610.          {
  611.             IStyleClient(currentToolTip).setStyle("styleName","errorTip");
  612.          }
  613.          sizeTip(currentToolTip);
  614.          if(currentToolTip is IStyleClient)
  615.          {
  616.             if(showEffect)
  617.             {
  618.                IStyleClient(currentToolTip).setStyle("showEffect",showEffect);
  619.             }
  620.             if(hideEffect)
  621.             {
  622.                IStyleClient(currentToolTip).setStyle("hideEffect",hideEffect);
  623.             }
  624.          }
  625.          if(Boolean(showEffect) || Boolean(hideEffect))
  626.          {
  627.             currentToolTip.addEventListener(EffectEvent.EFFECT_END,mx_internal::effectEndHandler);
  628.          }
  629.       }
  630.       
  631.       public function get showEffect() : IAbstractEffect
  632.       {
  633.          return _showEffect;
  634.       }
  635.       
  636.       mx_internal function toolTipMouseOverHandler(param1:MouseEvent) : void
  637.       {
  638.          mx_internal::checkIfTargetChanged(DisplayObject(param1.target));
  639.       }
  640.       
  641.       mx_internal function hideTip() : void
  642.       {
  643.          var _loc1_:ToolTipEvent = null;
  644.          var _loc2_:ISystemManager = null;
  645.          if(mx_internal::previousTarget)
  646.          {
  647.             _loc1_ = new ToolTipEvent(ToolTipEvent.TOOL_TIP_HIDE);
  648.             _loc1_.toolTip = currentToolTip;
  649.             mx_internal::previousTarget.dispatchEvent(_loc1_);
  650.          }
  651.          if(currentToolTip)
  652.          {
  653.             currentToolTip.visible = false;
  654.          }
  655.          if(mx_internal::isError)
  656.          {
  657.             if(currentTarget)
  658.             {
  659.                currentTarget.removeEventListener("change",mx_internal::changeHandler);
  660.             }
  661.          }
  662.          else if(mx_internal::previousTarget)
  663.          {
  664.             _loc2_ = getSystemManager(mx_internal::previousTarget);
  665.             _loc2_.removeEventListener(MouseEvent.MOUSE_DOWN,mx_internal::systemManager_mouseDownHandler);
  666.          }
  667.          if(!hideEffect)
  668.          {
  669.             mx_internal::hideEffectEnded();
  670.          }
  671.       }
  672.       
  673.       mx_internal function createTip() : void
  674.       {
  675.          var _loc1_:ToolTipEvent = new ToolTipEvent(ToolTipEvent.TOOL_TIP_CREATE);
  676.          currentTarget.dispatchEvent(_loc1_);
  677.          if(_loc1_.toolTip)
  678.          {
  679.             currentToolTip = _loc1_.toolTip;
  680.          }
  681.          else
  682.          {
  683.             currentToolTip = new toolTipClass();
  684.          }
  685.          currentToolTip.visible = false;
  686.          var _loc2_:ISystemManager = getSystemManager(currentTarget);
  687.          _loc2_.toolTipChildren.addChild(DisplayObject(currentToolTip));
  688.       }
  689.    }
  690. }
  691.  
  692.